import Vue from 'vue'
import * as api from '@/api/api'
import { isURL } from '@/utils/validate'
import { ACCESS_TOKEN } from '@/store/mutation-types'
import Storage_ from './LocalStorage'
import JSEncrypt from 'jsencrypt'
/**
 * 用于缓存数据
 */
export const Storage = Storage_

/**
 * 千分一逗
 * @param {*} number
 * @returns
 */
export function formatWithCommas(number) {
  return number.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}

/**
 * 获取身份证信息
 * @param {*} UUserCard 身份证号
 * @param {*} type 1 获取出生日期  2 获取性别  3 获取年龄
 * @returns 返回 type 对应的数据
 */
export const getIdCardInfo = (UUserCard, type) => {
  const typeList = {
    1: () => {
      //获取出生日期
      birth = UUserCard.substring(6, 10) + "-" + UUserCard.substring(10, 12) + "-" + UUserCard.substring(12, 14);
      return birth;
    },
    2: () => {
      //获取性别
      if (parseInt(UUserCard.substr(16, 1)) % 2 == 1) {
        //男
        return "男";
      } else {
        //女
        return "女";
      }
    },
    3: () => {
      //获取年龄
      var myDate = new Date();
      var month = myDate.getMonth() + 1;
      var day = myDate.getDate();
      var age = myDate.getFullYear() - UUserCard.substring(6, 10) - 1;
      if (UUserCard.substring(10, 12) < month || UUserCard.substring(10, 12) == month && UUserCard.substring(12, 14) <= day) {
        age++;
      }
      return age;
    },
  }
  return typeList[type] && typeList[type]() || ''
}

/**
 * 校验身份证地址和年龄
 * @param {*} pageSelf  页面 this
 * @param {*} idNum  身份证号
 * @param {*} idAddress 身份证上的地址
 */
export const verificationIDCardInfo = (pageSelf, idNum, idAddress) => {
  if (!idNum) {
    pageSelf.$message.warning('需要校验的身份证号有问题，请检查！')
    return false
  }
  if (!idAddress) {
    pageSelf.$message.warning('需要校验的地址有问题，请检查！')
    return false
  }

  const rulesList = {
    // 当#年龄#小于25岁时，提醒#不能办理公户# 系统检测到您所使用的身份证年龄小于25岁，可能拒绝此用户办理公户业务
    idNum: [[(age) => age < 25, () => `系统检测到您所使用的身份证年龄小于25岁，可能拒绝此用户办理公户业务!`]],
    // 当#身份证地址#含#村、场、组、队#时，提醒客户#系统检测到您所使用的身份证地址可能较偏远，后期办理公户时可能会影响为银行提供相关资料的进程#
    idAddress: [[(address) => {
      const rl = ['村', '场', '组', '队']
      // const rl = []
      let res = false
      for (let index = 0; index < rl.length; index++) {
        const key = rl[index];
        if (address.indexOf(key) >= 0) {
          res = true
          break
        }
      }
      return res
    }, () => `系统检测到您所使用的身份证地址可能较偏远，后期办理公户时可能会影响为银行提供相关资料的进程!`]]
  }


  const age_ = getIdCardInfo(idNum, 3)
  const getAge = rulesList['idNum'].find((item) => item[0](age_));
  // console.log('@@@@@@@@@@@@@@@@', idNum, age_, idAddress, getAge);
  const res = []
  if (getAge) {
    res.push(getAge[1]());
  }
   // 20240218 应业务要求关掉此校验规则
  // const getAddress = rulesList['idAddress'].find((item) => item[0](idAddress));
  // if (getAddress) {
  //   res.push(getAddress[1]());
  // }
  // window['UserInfo1'] = {idNum, age_, getAddress, getAge,res, t:'idNum, age_, getAddress, getAge,res'}

  return res
}


/**
 * 判断身份证是否在有效期内
 * @param {String} idCardEndDate 身份证有效期的结束日期 （如：2023-4-12）
 * @returns true 在有效期  false 不在有效期
 */
export const idCardDateAvailability = (idCardEndDate)=>{
  const currentDate = dateFormat()
  if(idCardEndDate=='长期'){
    return true
  }
  const DValue = DateDiff(idCardEndDate,currentDate)
  if(DValue>=0){
    return true
  }
  return false
}

/**
 * 日期计算 d1 - d2
 * @param {String} d1 2023-4-12
 * @param {String} d2 2023-4-13
 * @returns -1
 */
function DateDiff(d1, d2) {
  var day = 24 * 60 * 60 * 1000;
  try {
    var dateArr = d1.split("-");
    var checkDate = new Date();
    checkDate.setFullYear(dateArr[0], dateArr[1] - 1, dateArr[2]);
    var checkTime = checkDate.getTime();

    var dateArr2 = d2.split("-");
    var checkDate2 = new Date();
    checkDate2.setFullYear(dateArr2[0], dateArr2[1] - 1, dateArr2[2]);
    var checkTime2 = checkDate2.getTime();

    var cha = (checkTime - checkTime2) / day;
    return cha;
  } catch (e) {
    return false;
  }
}
/**
 * 获取当前系统日期
 * @returns  2023-4-13
 */
function dateFormat() {
  var date = new Date();
  return date.getFullYear() + '-' + (date.getMonth() + 1) + '-' + date.getDate();
}

/**
 * 获取当前季度的时间段
 * @return {Object} {StartDate,EndDate}  StartDate 季度开始时间  EndDate 季度结束时间
 */
export const CurrentQuarter = () => {
  var now = new Date(); //当前日期
  var nowDayOfWeek = now.getDay(); //今天本周的第几天
  var nowDay = now.getDate(); //当前日
  var nowMonth = now.getMonth(); //当前月
  var nowYear = now.getYear(); //当前年
  nowYear += (nowYear < 2000) ? 1900 : 0;

  function formatDate(date) {
    var myyear = date.getFullYear();
    var mymonth = date.getMonth() + 1;
    var myweekday = date.getDate();
    if (mymonth < 10) {
      mymonth = "0" + mymonth;
    }
    if (myweekday < 10) {
      myweekday = "0" + myweekday;
    }
    return (myyear + "-" + mymonth + "-" + myweekday);
  }


  function getQuarterStartMonth(theMonth) {
    if (!theMonth) {
      theMonth = nowMonth;
    }
    var quarterStartMonth = 0;
    if (theMonth < 3) {
      quarterStartMonth = 0;
    }
    if (2 < theMonth && theMonth < 6) {
      quarterStartMonth = 3;
    }
    if (5 < theMonth && theMonth < 9) {
      quarterStartMonth = 6;
    }
    if (theMonth > 8) {
      quarterStartMonth = 9;
    }
    return quarterStartMonth;
  }

  function getMonthDays(theYear, theMonth) {
    var monthStartDate = new Date(theYear, theMonth, 1);
    var monthEndDate = new Date(theYear, theMonth + 1, 1);
    var days = (monthEndDate - monthStartDate) / (1000 * 60 * 60 * 24);
    return days;
  }


  //获得本季度的开始日期
  function ghGetQuarterStartDate() {
    var quarterStartDate = new Date(nowYear, getQuarterStartMonth(), 1);
    return formatDate(quarterStartDate);
  }

  //或的本季度的结束日期
  function ghGetQuarterEndDate() {
    var quarterEndMonth = getQuarterStartMonth() + 2;
    var quarterStartDate = new Date(nowYear, quarterEndMonth,
      getMonthDays(nowYear, quarterEndMonth));
    return formatDate(quarterStartDate);
  }

  return { StartDate: ghGetQuarterStartDate(), EndDate: ghGetQuarterEndDate() }
}

/**
 * 属性数据扁平化
 * @param {Array} data 树形结构数组
 * @returns {Object} 扁平化后的数据
 */
export const dataFlattening = (data) => {
  const tempData = [...data]
  const resObj = {}
  const getData = (data_) => {
    data_.forEach(item => {
      const { id, parentId,status, addressName, children, invoiceId, invoiceName, labelEntname, labelOrgname,nodeDescription, nodeActivty, nodeName, nodeNature,organizationalList,labelOrgnameList } = item;
      let templabelOrgname = []
      if(!labelOrgname){
        templabelOrgname = labelOrgnameList
      }else{
        templabelOrgname = labelOrgname
      }
      // 判断是否可用 disabled  0-待审核;1-生效;2-驳回;3-停用;4-待审核(停用);5-待审核(启用);6-待生效;7-待停用;
      let tempDisabled = false // 默认值 false 启用
      const wList = [0,2,3,6,5] // 禁用名单
      if(wList.indexOf(status)>=0){
        tempDisabled = true
      }
      resObj[id] = { id, parentId, children, addressName,invoiceId, invoiceName, labelEntname,nodeDescription, labelOrgname:templabelOrgname,labelOrgnameList, nodeActivty, nodeName,organizationalList, nodeNature, disabled: tempDisabled,hasError: false ,organizationForm:'',}
      if (children && children.length > 0) {
        getData(children)
      }
    })
  }
  getData(tempData)
  return resObj
}

/**
 *
 */
export function timeFix() {
  const time = new Date()
  const hour = time.getHours()
  return hour < 9 ? '早上好' : (hour <= 11 ? '上午好' : (hour <= 13 ? '中午好' : (hour < 20 ? '下午好' : '晚上好')))
}

export function welcome() {
  const arr = ['休息一会儿吧', '准备吃什么呢?', '要不要打一把 DOTA', '我猜你可能累了']
  let index = Math.floor((Math.random() * arr.length))
  return arr[index]
}

/**
 * 获取URL上携带的参数
 * str:  url链接
 * name  获取参数名称
 */
export function carriedParameters(url, name) {
  return decodeURIComponent((new RegExp('[?|&]' + name + '=' + '([^&;]+?)(&|#|;|$)').exec(url) || [, ''])[1].replace(/\+/g, '%20')) || null;
}


/**
 * 复制内容
 * str:  需要复制内容
 * that:  this指向
 */
export function copyLinkContent(str, that) {
  var oInput = document.createElement("textarea"); //创建隐形textarea
  oInput.value = str; //
  document.body.appendChild(oInput);
  oInput.select();
  document.execCommand("Copy");
  oInput.remove();
  return that.$message.success('复制成功');
}

//传给数组 给数
export function getMenuCount(flowGroup,flows) {
  let num = 0
    for (let j = 0; j < flows.length; j++) {
      const flow = flows[j]
      if (flowGroup == flow.flowGroup) {
        num = flow.num
      }
  }
  // console.log(123567,num)
  return num
}


/**
 * 获取组合日期
 */
export function conversionDate(data) {
  const year = data.slice(0, 4);
  const month = data.substr(4);
  let day;
  //获取所在月份的天数
  if (month == 2) {
    if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
      day = 29;
    } else {
      day = 28;
    }
  } else if (month == 4 || month == 6 || month == 9 || month == 11) {
    day = 30;
  } else {
    day = 31;
  }
  return month + '.01~' + month + '.' + day + '(' + year + ')'
}

/**
 * 金钱  元 => 分
 */
export function conversionBranch(num) {
  if (num == 0 || num == '') {
    num = 0
  } else {
    num = Math.round(num * 10000) / 100
  }
  return num
}

/**
 * 金钱  分 => 元
 */
export function conversionElement(num) {
  if (num == 0 || num == '') {
    num = 0
  } else {
    num = Math.round(num * 100) / 10000
  }
  return num
}

/**
 * 金钱  万元 => 分
 */
export function conversionManyBranch(num) {
  if (num == 0 || num == '') {
    num = 0
  } else {
    num = Math.round(num * 100000000) / 100
  }
  return num
}

/**
 * 金钱  分 => 万元
 */
export function conversionManyElement(num) {
  if (num == 0 || num == '') {
    num = 0
  } else {
    num = Math.round(num * 100) / 100000000
  }
  return num
}

/**
 * 费率  百分比转换    0.6 => 60%
 */
export function percentConversion(num) {
  if (num == 0) {
    num = 0
  } else if (num > 0) {
    num = Math.round(num * 10000) / 100
  }
  return num
}

/**
 * 费率  百分比转换    60% => 0.6
 */
export function percentageConverse(num) {
  if (num == 0) {
    num = 0
  } else if (num >= 100) {
    num = 1
  } else if (num > 0 && num < 100) {
    num = Math.round(num * 100) / 10000
  }
  return num
}

/**
 * 加法
 */
export function accAdd(arg1, arg2) {
  var r1, r2, m, c;
  try {
    r1 = arg1.toString().split(".")[1].length;
  } catch (e) {
    r1 = 0;
  }
  try {
    r2 = arg2.toString().split(".")[1].length;
  } catch (e) {
    r2 = 0;
  }
  c = Math.abs(r1 - r2);
  m = Math.pow(10, Math.max(r1, r2));
  if (c > 0) {
    var cm = Math.pow(10, c);
    if (r1 > r2) {
      arg1 = Number(arg1.toString().replace(".", ""));
      arg2 = Number(arg2.toString().replace(".", "")) * cm;
    } else {
      arg1 = Number(arg1.toString().replace(".", "")) * cm;
      arg2 = Number(arg2.toString().replace(".", ""));
    }
  } else {
    arg1 = Number(arg1.toString().replace(".", ""));
    arg2 = Number(arg2.toString().replace(".", ""));
  }
  return (arg1 + arg2) / m;
}

/**
 * 减法
 */
export function accSub(arg1, arg2) {
  var r1, r2, m, n;
  try {
    r1 = arg1.toString().split(".")[1].length;
  } catch (e) {
    r1 = 0;
  }
  try {
    r2 = arg2.toString().split(".")[1].length;
  } catch (e) {
    r2 = 0;
  }
  m = Math.pow(10, Math.max(r1, r2)); //last modify by deeka //动态控制精度长度
  n = (r1 >= r2) ? r1 : r2;

  return ((arg1 * m - arg2 * m) / m).toFixed(n);
}

/**
 * 保留两位小数（小数后第三位不可输入）
 */
export function limitDigits(value) {
  let reg = /^(-)*(\d+)\.(\d\d).*$/;
  let val;
  if (value) {
    val = (value.toString()).replace(/￥\s?|(,*)/g, '').replace(reg, '$1$2.$3');
  } else {
    val = value;
  }

  return val;
}
//加密方式
export function encryptIt(key,value){
  var encryptor = new JSEncrypt()  // 创建加密对象实例
  //之前ssl生成的公钥，复制的时候要小心不要有空格
  var pubKey =  key
  encryptor.setPublicKey(pubKey)//设置公钥
  return encryptor.encrypt(value)  // 对内容进行加密
}
/**
 * @param {string} value - 输入的值
 // * @param {string} name - 匹配的对象属性 [mkPrice | slPrice]
 */
export function limitInput(value) {
  return ("" + value) // 第一步：转成字符串
      .replace(/[^\d^\.]+/g, "") // 第二步：把不是数字，不是小数点的过滤掉
      .replace(/^0+(\d)/, "$1") // 第三步：第一位0开头，0后面为数字，则过滤掉，取后面的数字
      .replace(/^\./, "0.") // 第四步：如果输入的第一位为小数点，则替换成 0. 实现自动补全
      .match(/^\d*(\.?\d{0,2})/g)[0] || ""; // 第五步：最终匹配得到结果 以数字开头，只有一个小数点，而且小数点后面只能有0到2位小数
}

/**
 * 数字金额转汉字金额
 * val为字符串类型
 */
export function toChies(val) {
  //汉字的数字
  var cnNums = new Array('零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖');
  //基本单位
  var cnIntRadice = new Array('', '拾', '佰', '仟');
  //对应整数部分扩展单位
  var cnIntUnits = new Array('', '万', '亿', '兆');
  //对应小数部分单位
  var cnDecUnits = new Array('角', '分', '毫', '厘');
  //整数金额时后面跟的字符
  var cnInteger = '整';
  //整型完以后的单位
  var cnIntLast = '元';
  //最大处理的数字
  var maxNum = 999999999999999.9999;
  //金额整数部分
  var integerNum;
  //金额小数部分
  var decimalNum;
  //输出的中文金额字符串
  var chineseStr = '';
  //分离金额后用的数组，预定义
  var parts;
  if (val == '') { return ''; }
  val = parseFloat(val);
  if (val >= maxNum) {
    //超出最大处理数字
    return '';
  }
  if (val == 0) {
    chineseStr = cnNums[0] + cnIntLast + cnInteger;
    return chineseStr;
  }
  //转换为字符串
  val = val.toString();
  if (val.indexOf('.') == -1) {
    integerNum = val;
    decimalNum = '';
  } else {
    parts = val.split('.');
    integerNum = parts[0];
    decimalNum = parts[1].substr(0, 4);
  }
  //获取整型部分转换
  if (parseInt(integerNum, 10) > 0) {
    var zeroCount = 0;
    var IntLen = integerNum.length;
    for (var i = 0; i < IntLen; i++) {
      var n = integerNum.substr(i, 1);
      var p = IntLen - i - 1;
      var q = p / 4;
      var m = p % 4;
      if (n == '0') {
        zeroCount++;
      } else {
        if (zeroCount > 0) {
          chineseStr += cnNums[0];
        }
        //归零
        zeroCount = 0;
        chineseStr += cnNums[parseInt(n)] + cnIntRadice[m];
      }
      if (m == 0 && zeroCount < 4) {
        chineseStr += cnIntUnits[q];
      }
    }
    chineseStr += cnIntLast;
  }
  //小数部分
  if (decimalNum != '') {
    var decLen = decimalNum.length;
    for (var i = 0; i < decLen; i++) {
      var n = decimalNum.substr(i, 1);
      if (n != '0') {
        chineseStr += cnNums[Number(n)] + cnDecUnits[i];
      }
    }
  }
  if (chineseStr == '') {
    chineseStr += cnNums[0] + cnIntLast + cnInteger;
  } else if (decimalNum == '') {
    chineseStr += cnInteger;
  }
  return chineseStr;
};

/**
 * 银行卡号每四位一个间隔空格
 * val为字符串类型
 */
export function cardInterval(val) {
  // let value = val.toString();
  let value = val.replace(/\s/g, '').replace(/[^\d]/g, '').replace(/(\d{4})(?=\d)/g, '$1 ');
  // console.log(value)
  return value
}

/**
 * 截取文件名长度
 */
export function cutstr(str, len) {
  if (str) {
    var temp,
      icount = 0,
      patrn = /[^\x00-\xff]/,
      strre = "";
    let pos = str.lastIndexOf(".");
    let lastName = str.substring(pos, str.length);
    if (str.length > 20) {
      for (var i = 0; i < str.length; i++) {
        if (icount < len - 1) {
          temp = str.substr(i, 1);
          if (patrn.exec(temp) == null) {
            icount = icount + 1
          } else {
            icount = icount + 2
          }
          strre += temp
        } else {
          break;
        }
      }
      return strre + "..." + lastName;
    } else {
      return str;
    }
  }
}

/**
 * 姓名加星 区分
 */
export function nameFilter(val) {
  // if (val.includes('·')){
  //   let valStart = getCaptionBefore(val,'\·');
  //   let valEnd = getCaptionAfter(val,'\·');
  //   nameDistinguish(valStart);
  //   nameDistinguish(valEnd);
  //   let str = nameDistinguish(valStart) + '·' + nameDistinguish(valEnd);
  //   return str;
  // }else{
  //   return nameDistinguish(val);
  // }

  return val;
}

/**
 * 姓名加星
 */
export function nameDistinguish(val) {
  let len = val.length - 2;
  let str = '';
  for (let i = 0; i < len; i++) {
    str += '*'
  }
  let reg;
  if (val.length > 2) {
    reg = /^(.).+(.)$/;
    return val.replace(reg, "$1" + str + "$2");
  } else if (val.length == 2) {
    reg = /^(.).+$/;
    return val.replace(reg, "$1*")
  } else {
    return val;
  }
}

/*
 * 截取指定符号前面所有字符
 */
export function getCaptionBefore(obj, symbol) {
  // var index = obj.lastIndexOf("\·");
  var index = obj.lastIndexOf("" + symbol + "");
  obj = obj.substring(0, index);
  return obj;
}

/*
 * 截取指定符号后面所有字符
 */
export function getCaptionAfter(obj, symbol) {
  // var index = obj.lastIndexOf("\·");
  var index = obj.lastIndexOf("" + symbol + "");
  obj = obj.substring(index + 1, obj.length);
  return obj;
}

/*
 * 截取文件名
 */
export function getCaptionFileName(name) {
  let aName = '';
  // let jieStr = name.substr(name.lastIndexOf('/', name.lastIndexOf('/') - 1) + 1).substring(0,name.substr(name.lastIndexOf('/', name.lastIndexOf('/') - 1) + 1).lastIndexOf('/'));
  // var index = name.lastIndexOf('\/');
  // if(index != -1){
  //   let result = name.substring(index + 1,name.length);
  //   let newName = decodeURIComponent(result);
  //   if(jieStr == 'detail'){
  //     aName = newName.substring(newName.lastIndexOf('detail/') + 1,newName.length);
  //   }else{
  //     if (newName.lastIndexOf('_') != -1){
  //       aName = newName.substring(newName.lastIndexOf('_') + 1,newName.length);
  //     }else if(newName.lastIndexOf('-')){
  //       aName = newName.substring(newName.lastIndexOf('-') + 16,newName.length);
  //     }else{
  //       aName = newName;
  //     }
  //   }
  // }else{
  //   aName = name;
  // }
  if (aName == '' || aName.length == 0) {
    aName = getFileName(decodeURI(name))
  }
  if (aName == '' || aName.length == 0) {
    aName = getFileName2(decodeURI(name))
  }
  return aName
}
function getFileName(path) {
  var pos1 = path.lastIndexOf('/');
  var pos2 = path.lastIndexOf('\\');
  var pos = Math.max(pos1, pos2);
  if (pos < 0)
    return path;
  else
    return path.substring(pos + 1);
}
function getFileName2(path) {
  var pos1 = path.lastIndexOf('/');
  var pos2 = path.lastIndexOf('\\');
  var pos = Math.max(pos1, pos2);
  if (pos < 0) {
    return path;
  } else {
    let tempPath = path.substring(pos + 1);
    return tempPath.substring(0, tempPath.lastIndexOf("."));
  }
}


/**
 * 手机号，身份证号,银行卡号加星
 * 类型   bankCard 银行卡号  mobileCard 手机号，身份证号
 */
export function numberFilter(val, type) {
  let len, reg;
  if (type == 'mobileCard') {
    reg = /^(.{3}).*(.{4})$/;
    len = val.length - 7;
  } else if (type == 'bankCard') {
    reg = /^(.{4}).*(.{4})$/;
    len = val.length - 8;
  }
  let str = '';
  for (let i = 0; i < len; i++) {
    str += '*'
  }
  // return val.replace(reg,"$1" + str +"$2");
  return val;
}

/**
 * 3秒后执行当前操作
 */
export function sleep(n) {
  var start = new Date().getTime();//定义起始时间的毫秒数
  while (true) {
    var time = new Date().getTime();//每次执行循环取得一次当前时间的毫秒数
    if (time - start > n) {//如果当前时间的毫秒数减去起始时间的毫秒数大于给定的毫秒数，即结束循环
      break;
    }
  }
}

/**
 * 深度克隆对象、数组
 * @param obj 被克隆的对象
 * @return 克隆后的对象
 */
export function cloneObject(obj) {
  return JSON.parse(JSON.stringify(obj))
}

/**
 * 触发 window.resize
 */
export function triggerWindowResizeEvent() {
  let event = document.createEvent('HTMLEvents')
  event.initEvent('resize', true, true)
  event.eventType = 'message'
  window.dispatchEvent(event)
}

/**
 * 过滤对象中为空的属性
 * @param obj
 * @returns {*}
 */
export function filterObj(obj) {
  if (!(typeof obj == 'object')) {
    return;
  }
  for (let key in obj) {
    if (obj.hasOwnProperty(key)
      && (obj[key] == null || obj[key] == undefined || obj[key] === '')) {
      delete obj[key];
    }
  }
  return obj;
}

/**
 * 判断字段值不为null或undefined
 */
export function judgeNull(val) {
  let Boolean;
  if (Object.prototype.toString.call(val) == '[object Null]' || Object.prototype.toString.call(val) == '[object Undefined]'){
    Boolean = true;
  }else {
    Boolean = false;
  }
  return Boolean;
}

/**
 * 过滤数组内的空值
 */
export function filterNull(arr) {
  return arr.filter(
    item=>!["",null,'null',undefined,'undefined',NaN,false,true].includes(item)
  );
}

/**
 * 过滤空数组
 */
export function filterNullArr(arr) {
  return arr.filter(function (a) {
    return a.some(function (val) {
      return val !== undefined;
    });
  });
}

/**
 * 时间格式化
 * @param value
 * @param fmt
 * @returns {*}
 */
export function formatDate(value, fmt) {
  let regPos = /^\d+(\.\d+)?$/;
  if (regPos.test(value)) {
    //如果是数字
    let getDate = new Date(value);
    let o = {
      'M+': getDate.getMonth() + 1,
      'd+': getDate.getDate(),
      'h+': getDate.getHours(),
      'm+': getDate.getMinutes(),
      's+': getDate.getSeconds(),
      'q+': Math.floor((getDate.getMonth() + 3) / 3),
      'S': getDate.getMilliseconds()
    };
    if (/(y+)/.test(fmt)) {
      fmt = fmt.replace(RegExp.$1, (getDate.getFullYear() + '').substr(4 - RegExp.$1.length))
    }
    for (let k in o) {
      if (new RegExp('(' + k + ')').test(fmt)) {
        fmt = fmt.replace(RegExp.$1, (RegExp.$1.length === 1) ? (o[k]) : (('00' + o[k]).substr(('' + o[k]).length)))
      }
    }
    return fmt;
  } else {
    //TODO
    value = value.trim();
    return value.substr(0, fmt.length);
  }
}

// 生成首页路由
export function generateIndexRouter(data) {
  let indexRouter = [{
    path: '/',
    name: 'index-index',
    //component: () => import('@/components/layouts/BasicLayout'),
    component: resolve => require(['@/components/layouts/TabLayout'], resolve),
    meta: { title: '首页' },
    redirect: '/index/index',
    children: [
      ...generateChildRouters(data)
    ]
  }, {
    "path": "*", "redirect": "/404", "hidden": true
  }]
  return indexRouter;
}

// 生成嵌套路由（子路由）

function generateChildRouters(data) {
  const routers = [];
  for (let item of data) {
    let component = "";
    if (item.component.indexOf("layouts") >= 0) {
      component = "components/" + item.component;
    } else {
      component = "views/" + item.component;
    }

    // eslint-disable-next-line
    let URL = (item.meta.url || '').replace(/{{([^}}]+)?}}/g, (s1, s2) => eval(s2)) // URL支持{{ window.xxx }}占位符变量
    if (isURL(URL)) {
      item.meta.url = URL;
    }

    let componentPath
    componentPath = resolve => require(['@/' + component + '.vue'], resolve)

    let menu = {
      path: item.path,
      name: item.name,
      redirect: item.redirect,
      component: componentPath,
      //component: resolve => require(['@/' + component+'.vue'], resolve),
      hidden: item.hidden,
      //component:()=> import(`@/views/${item.component}.vue`),
      meta: {
        title: item.meta.title,
        icon: item.meta.icon,
        url: item.meta.url,
        permissionList: item.meta.permissionList,
        keepAlive: item.meta.keepAlive,
        /*update_begin author:wuxianquan date:20190908 for:赋值 */
        internalOrExternal: item.meta.internalOrExternal,
        /*update_end author:wuxianquan date:20190908 for:赋值 */
        componentName: item.meta.componentName
      }
    }
    if (item.alwaysShow) {
      menu.alwaysShow = true;
      menu.redirect = menu.path;
    }
    if (item.children && item.children.length > 0) {
      menu.children = [...generateChildRouters(item.children)];
    }
    //--update-begin----author:scott---date:20190320------for:根据后台菜单配置，判断是否路由菜单字段，动态选择是否生成路由（为了支持参数URL菜单）------
    //判断是否生成路由
    if (item.route && item.route === '0') {
      //console.log(' 不生成路由 item.route：  '+item.route);
      //console.log(' 不生成路由 item.path：  '+item.path);
    } else {
      routers.push(menu);
    }
    //--update-end----author:scott---date:20190320------for:根据后台菜单配置，判断是否路由菜单字段，动态选择是否生成路由（为了支持参数URL菜单）------
  }
  return routers
}

/**
 * 随机生成数字
 *
 * 示例：生成长度为 12 的随机数：randomNumber(12)
 * 示例：生成 3~23 之间的随机数：randomNumber(3, 23)
 *
 * @param1 最小值 | 长度
 * @param2 最大值
 * @return int 生成后的数字
 */
export function randomNumber() {
  // 生成 最小值 到 最大值 区间的随机数
  const random = (min, max) => {
    return Math.floor(Math.random() * (max - min + 1) + min)
  }
  if (arguments.length === 1) {
    let [length] = arguments
    // 生成指定长度的随机数字，首位一定不是 0
    let nums = [...Array(length).keys()].map((i) => (i > 0 ? random(0, 9) : random(1, 9)))
    return parseInt(nums.join(''))
  } else if (arguments.length >= 2) {
    let [min, max] = arguments
    return random(min, max)
  } else {
    return Number.NaN
  }
}

/**
 * 随机生成字符串
 * @param length 字符串的长度
 * @param chats 可选字符串区间（只会生成传入的字符串中的字符）
 * @return string 生成的字符串
 */
export function randomString(length, chats) {
  if (!length) length = 1
  if (!chats) chats = '0123456789qwertyuioplkjhgfdsazxcvbnm'
  let str = ''
  for (let i = 0; i < length; i++) {
    let num = randomNumber(0, chats.length - 1)
    str += chats[num]
  }
  return str
}

/**
 * 随机生成uuid
 * @return string 生成的uuid
 */
export function randomUUID() {
  let chats = '0123456789abcdef'
  return randomString(32, chats)
}

/**
 * 下划线转驼峰
 * @param string
 * @returns {*}
 */
export function underLine2CamelCase(string) {
  return string.replace(/_([a-z])/g, function (all, letter) {
    return letter.toUpperCase();
  });
}

/**
 * 判断是否显示办理按钮
 * @param bpmStatus
 * @returns {*}
 */
export function showDealBtn(bpmStatus) {
  if (bpmStatus != "1" && bpmStatus != "3" && bpmStatus != "4") {
    return true;
  }
  return false;
}

/**
 * 增强CSS，可以在页面上输出全局css
 * @param css 要增强的css
 * @param id style标签的id，可以用来清除旧样式
 */
export function cssExpand(css, id) {
  let style = document.createElement('style')
  style.type = "text/css"
  style.innerHTML = `@charset "UTF-8"; ${css}`
  // 清除旧样式
  if (id) {
    let $style = document.getElementById(id)
    if ($style != null) $style.outerHTML = ''
    style.id = id
  }
  // 应用新样式
  document.head.appendChild(style)
}


/** 用于js增强事件，运行JS代码，可以传参 */
// options 所需参数：
//    参数名         类型            说明
//    vm             VueComponent    vue实例
//    event          Object          event对象
//    jsCode         String          待执行的js代码
//    errorMessage   String          执行出错后的提示（控制台）
export function jsExpand(options = {}) {

  // 绑定到window上的keyName
  let windowKeyName = 'J_CLICK_EVENT_OPTIONS'
  if (typeof window[windowKeyName] != 'object') {
    window[windowKeyName] = {}
  }

  // 随机生成JS增强的执行id，防止冲突
  let id = randomString(16, 'qwertyuioplkjhgfdsazxcvbnm'.toUpperCase())
  // 封装按钮点击事件
  let code = `
    (function (o_${id}) {
      try {
        (function (globalEvent, vm) {
          ${options.jsCode}
        })(o_${id}.event, o_${id}.vm)
      } catch (e) {
        o_${id}.error(e)
      }
      o_${id}.done()
    })(window['${windowKeyName}']['EVENT_${id}'])
  `
  // 创建script标签
  const script = document.createElement('script')
  // 将需要传递的参数挂载到window对象上
  window[windowKeyName]['EVENT_' + id] = {
    vm: options.vm,
    event: options.event,
    // 当执行完成时，无论如何都会调用的回调事件
    done() {
      // 执行完后删除新增的 script 标签不会撤销执行结果（已产生的结果不会被撤销）
      script.outerHTML = ''
      delete window[windowKeyName]['EVENT_' + id]
    },
    // 当js运行出错的时候调用的事件
    error(e) {
      console.group(`${options.errorMessage || '用户自定义JS增强代码运行出错'}（${new Date()}）`)
      console.error(e)
      console.groupEnd()
    }
  }
  // 将事件挂载到document中
  script.innerHTML = code
  document.body.appendChild(script)
}


/**
 * 重复值验证工具方法
 *
 * 使用示例：
 * { validator: (rule, value, callback) => validateDuplicateValue('sys_fill_rule', 'rule_code', value, this.model.id, callback) }
 *
 * @param tableName 被验证的表名
 * @param fieldName 被验证的字段名
 * @param fieldVal 被验证的值
 * @param dataId 数据ID，可空
 * @param callback
 */
export function validateDuplicateValue(tableName, fieldName, fieldVal, dataId, callback) {
  if (fieldVal) {
    let params = { tableName, fieldName, fieldVal, dataId }
    api.duplicateCheck(params).then(res => {
      res['success'] ? callback() : callback(res['message'])
    }).catch(err => {
      callback(err.message || err)
    })
  } else {
    callback()
  }
}

/**
 * 根据编码校验规则code，校验传入的值是否合法
 *
 * 使用示例：
 * { validator: (rule, value, callback) => validateCheckRule('common', value, callback) }
 *
 * @param ruleCode 编码校验规则 code
 * @param value 被验证的值
 * @param callback
 */
export function validateCheckRule(ruleCode, value, callback) {
  if (ruleCode && value) {
    value = encodeURIComponent(value)
    api.checkRuleByCode({ ruleCode, value }).then(res => {
      res['success'] ? callback() : callback(res['message'])
    }).catch(err => {
      callback(err.message || err)
    })
  } else {
    callback()
  }
}

/**
 * 如果值不存在就 push 进数组，反之不处理
 * @param array 要操作的数据
 * @param value 要添加的值
 * @param key 可空，如果比较的是对象，可能存在地址不一样但值实际上是一样的情况，可以传此字段判断对象中唯一的字段，例如 id。不传则直接比较实际值
 * @returns {boolean} 成功 push 返回 true，不处理返回 false
 */
export function pushIfNotExist(array, value, key) {
  for (let item of array) {
    if (key && (item[key] === value[key])) {
      return false
    } else if (item === value) {
      return false
    }
  }
  array.push(value)
  return true
}

/**
 * 可用于判断是否成功
 * @type {symbol}
 */
export const succeedSymbol = Symbol()
/**
 * 可用于判断是否失败
 * @type {symbol}
 */
export const failedSymbol = Symbol()

/**
 * 使 promise 无论如何都会 resolve，除非传入的参数不是一个Promise对象或返回Promise对象的方法
 * 一般用在 Promise.all 中
 *
 * @param promise 可传Promise对象或返回Promise对象的方法
 * @returns {Promise<any>}
 */
export function alwaysResolve(promise) {
  return new Promise((resolve, reject) => {
    let p = promise
    if (typeof promise === 'function') {
      p = promise()
    }
    if (p instanceof Promise) {
      p.then(data => {
        resolve({ type: succeedSymbol, data })
      }).catch(error => {
        resolve({ type: failedSymbol, error })
      })
    } else {
      reject('alwaysResolve: 传入的参数不是一个Promise对象或返回Promise对象的方法')
    }
  })
}

/**
 * 简单实现防抖方法
 *
 * 防抖(debounce)函数在第一次触发给定的函数时，不立即执行函数，而是给出一个期限值(delay)，比如100ms。
 * 如果100ms内再次执行函数，就重新开始计时，直到计时结束后再真正执行函数。
 * 这样做的好处是如果短时间内大量触发同一事件，只会执行一次函数。
 *
 * @param fn 要防抖的函数
 * @param delay 防抖的毫秒数
 * @returns {Function}
 */
export function simpleDebounce(fn, delay = 100) {
  let timer = null
  return function () {
    let args = arguments
    if (timer) {
      clearTimeout(timer)
    }
    timer = setTimeout(() => {
      fn.apply(this, args)
    }, delay)
  }
}

/**
 * 不用正则的方式替换所有值
 * @param text 被替换的字符串
 * @param checker  替换前的内容
 * @param replacer 替换后的内容
 * @returns {String} 替换后的字符串
 */
export function replaceAll(text, checker, replacer) {
  let lastText = text
  text = text.replace(checker, replacer)
  if (lastText !== text) {
    return replaceAll(text, checker, replacer)
  }
  return text
}

/**
 * 获取事件冒泡路径，兼容 IE11，Edge，Chrome，Firefox，Safari
 * 目前使用的地方：JEditableTable Span模式
 */
export function getEventPath(event) {
  let target = event.target
  let path = (event.composedPath && event.composedPath()) || event.path

  if (path != null) {
    return (path.indexOf(window) < 0) ? path.concat(window) : path
  }

  if (target === window) {
    return [window]
  }

  let getParents = (node, memo) => {
    memo = memo || []
    const parentNode = node.parentNode

    if (!parentNode) {
      return memo
    } else {
      return getParents(parentNode, memo.concat(parentNode))
    }
  }
  return [target].concat(getParents(target), window)
}

/**
 * 根据组件名获取父级
 * @param vm
 * @param name
 * @returns {Vue | null|null|Vue}
 */
export function getVmParentByName(vm, name) {
  let parent = vm.$parent
  if (parent && parent.$options) {
    if (parent.$options.name === name) {
      return parent
    } else {
      let res = getVmParentByName(parent, name)
      if (res) {
        return res
      }
    }
  }
  return null
}

/**
 * 使一个值永远不会为（null | undefined）
 *
 * @param value 要处理的值
 * @param def 默认值，如果value为（null | undefined）则返回的默认值，可不传，默认为''
 */
export function neverNull(value, def) {
  return value == null ? (neverNull(def, '')) : value
}

/**
 * 根据元素值移除数组中的一个元素
 * @param array 数组
 * @param prod 属性名
 * @param value 属性值
 * @returns {string}
 */
export function removeArrayElement(array, prod, value) {
  let index = -1
  for (let i = 0; i < array.length; i++) {
    if (array[i][prod] == value) {
      index = i;
      break;
    }
  }
  if (index >= 0) {
    array.splice(index, 1);
  }
}

/** 判断是否是OAuth2APP环境 */
export function isOAuth2AppEnv() {
  return /wxwork|dingtalk/i.test(navigator.userAgent)
}

/**
 * 获取积木报表打印地址
 * @param url
 * @param id
 * @param open 是否自动打开
 * @returns {*}
 */
export function getReportPrintUrl(url, id, open) {
  // URL支持{{ window.xxx }}占位符变量
  url = url.replace(/{{([^}]+)?}}/g, (s1, s2) => eval(s2))
  if (url.includes('?')) {
    url += '&'
  } else {
    url += '?'
  }
  url += `id=${id}`
  url += `&token=${Vue.ls.get(ACCESS_TOKEN)}`
  if (open) {
    window.open(url)
  }
  return url
}

/**
 * JS实现AOP切面
 *
 * @param obj 包含函数的对象
 * @param funcName 要切面的函数名
 * @param callback 执行方法前的回调，用于切面，callback的返回值就是funcName最终的返回值
 */
export function aspectAroundFunction(obj, funcName, callback) {
  if (typeof callback !== 'function' || !obj) {
    console.warn('【aspectAroundFunction】obj或callback格式不正确')
    return
  }
  // 保存原来的函数
  let func = obj[funcName]
  if (typeof func !== 'function') {
    console.warn('【aspectAroundFunction】' + funcName + '不是一个方法')
    return
  }
  // 赋值新方法
  // 实现当外部调用 funcName 时，首先调用我定义的新方法
  // 然后调用传入的callback方法，以决定是否执行 funcName，以及更改参数、返回值
  obj[funcName] = function (...args) {
    return callback({
      args,
      // 只有执行 proceed 才会真正执行给定的 funcName 方法
      proceed() {
        try {
          return func.apply(obj, args)
        } catch (e) {
          console.error(e)
        }
      },
    })
  }
}
